home *** CD-ROM | disk | FTP | other *** search
/ Workbench Add-On / Workbench Add-On - Volume 1.iso / Dev / Oberon / source / FPE / Data.mod < prev    next >
Text File  |  1995-06-29  |  17KB  |  657 lines
  1. (*************************************************************************
  2.  
  3.      $RCSfile: Data.mod $
  4.   Description: Global data declarations and operations for the FPE utility
  5.                program.
  6.  
  7.    Created by: fjc (Frank Copeland)
  8.     $Revision: 1.12 $
  9.       $Author: fjc $
  10.         $Date: 1995/05/08 16:41:15 $
  11.  
  12.   Copyright © 1993-1995, Frank Copeland.
  13.   This file is part of FPE.
  14.   See FPE.doc for conditions of use and distribution.
  15.  
  16.   Log entries are at the end of the file.
  17.  
  18. *************************************************************************)
  19.  
  20. <* STANDARD- *> <* INITIALISE- *> <* MAIN- *> <*$ NilChk- *>
  21.  
  22. MODULE Data;
  23.  
  24. IMPORT
  25.   SYS := SYSTEM, Kernel, e := Exec, es := ExecSupport, eu := ExecUtil,
  26.   u := Utility, d := Dos, du := DosUtil, is := IntuiSup,
  27.   isu := IntuiSupUtil, str := Strings, str2 := Strings2;
  28.  
  29. CONST
  30.  
  31.   NumFiles * = 4;
  32.   NumTools * = 12;
  33.  
  34.   FileChars *      = 32;
  35.   ExtensionChars * = 8;
  36.   PathChars *      = 254;
  37.   ButtonChars *    = 10;
  38.   ConsoleChars *   = 60;
  39.  
  40.   Notice    = "FPE Notice";
  41.  
  42.   FPEPF = 046504500H;
  43.   PrefsVersion = 1;
  44.  
  45. TYPE
  46.  
  47.   FileName * = ARRAY FileChars + 1 OF CHAR;
  48.   Path * = ARRAY PathChars + 1 OF CHAR;
  49.   Extension * = ARRAY ExtensionChars + 1 OF CHAR;
  50.  
  51.   ModuleNodePtr * = POINTER [2] TO ModuleNode;
  52.   ModuleNode = RECORD [2] (e.Node)
  53.     modName : FileName;
  54.   END; (* ModuleNode *)
  55.  
  56.   ButtonText = ARRAY ButtonChars + 1 OF CHAR;
  57.   Console = ARRAY ConsoleChars + 1 OF CHAR;
  58.  
  59.   ToolInfo * = RECORD
  60.     title *      : ButtonText;
  61.     command *,
  62.     arguments *  : Path;
  63.     isActive *,
  64.     hasConsole * : BOOLEAN;
  65.     console *    : Console;
  66.     stack *      : LONGINT;
  67.   END; (* ToolInfo *)
  68.  
  69.   FileSet         = SYS.BYTESET;
  70.   ToolsArray      = ARRAY NumTools OF ToolInfo;
  71.   SkeletonsArray  = ARRAY NumFiles OF Path;
  72.   ExtensionsArray = ARRAY NumFiles OF Extension;
  73.  
  74. VAR
  75.  
  76.   currentPath *     : Path;
  77.   programName *     : FileName;
  78.   moduleList *      : e.List;
  79.   currentModule *   : ModuleNodePtr;
  80.   currentModuleNo * : LONGINT;
  81.   currentFiles *    : FileSet;
  82.   tools *           : ToolsArray;
  83.   extensions *      : ExtensionsArray;
  84.   currentDir *      : d.FileLockPtr;
  85.  
  86.   DefSetupPath : Path;
  87.   AltSetupPath : Path;
  88.   (*skeletons : SkeletonsArray;*)
  89.   (*icon      : Path;*)
  90.  
  91.  
  92. (*------------------------------------*)
  93. PROCEDURE ChangeDirectory * ( newDir : ARRAY OF CHAR );
  94.  
  95.   VAR result : LONGINT; newLock, oldDir : d.FileLockPtr;
  96.  
  97. <*$CopyArrays-*>
  98. BEGIN (* ChangeDirectory *)
  99.   newLock := d.Lock (newDir, d.sharedLock);
  100.   IF newLock # NIL THEN
  101.     oldDir := d.CurrentDir (newLock);
  102.     d.UnLock (currentDir); currentDir := newLock;
  103.     ASSERT (d.NameFromLock (currentDir, currentPath, PathChars))
  104.   ELSE
  105.     isu.DoNotice (NIL, SYS.ADR (Notice), "Could not lock new directory");
  106.   END
  107. END ChangeDirectory;
  108.  
  109. (*------------------------------------*)
  110. PROCEDURE MakeModule * ( module : ARRAY OF CHAR );
  111.  
  112. VAR
  113.   newNode : ModuleNodePtr;
  114.  
  115. <*$CopyArrays-*>
  116. BEGIN (* MakeModule *)
  117.   NEW (newNode); ASSERT (newNode # NIL, 137);
  118.   newNode.name := SYS.ADR(newNode.modName);
  119.   COPY (module, newNode.modName);
  120.   e.AddTail (moduleList, newNode);
  121.   IF currentModule = NIL THEN
  122.     currentModule := SYS.VAL (ModuleNodePtr, moduleList.head);
  123.     currentModuleNo := 0
  124.   END
  125. END MakeModule;
  126.  
  127.  
  128. (*------------------------------------*)
  129. PROCEDURE RemoveModule * ();
  130.  
  131. VAR module : ModuleNodePtr;
  132.  
  133. BEGIN (* RemoveModule *)
  134.   IF currentModule # NIL THEN
  135.     module := currentModule;
  136.     IF module.succ.succ = NIL THEN
  137.       currentModule := SYS.VAL (ModuleNodePtr, moduleList.head);
  138.       currentModuleNo := 0
  139.     ELSE
  140.       currentModule := SYS.VAL (ModuleNodePtr, module.succ);
  141.     END;
  142.     e.Remove (module);
  143.     SYS.DISPOSE (module)
  144.   END
  145. END RemoveModule;
  146.  
  147.  
  148. (*------------------------------------*)
  149. PROCEDURE ScanModules * () : BOOLEAN;
  150.  
  151. VAR
  152.   module : FileName;
  153.   fileInfo : d.FileInfoBlockPtr;
  154.   file, fileLength, dotPos : INTEGER;
  155.   extLength : ARRAY NumFiles OF INTEGER;
  156.   extension : Extension;
  157.   result : BOOLEAN;
  158.   thisModule : e.MinNodePtr;
  159.  
  160. BEGIN (* ScanModules *)
  161.   result := TRUE;
  162.   NEW (fileInfo); ASSERT (fileInfo # NIL, 137);
  163.  
  164.   thisModule := SYS.VAL (e.MinNodePtr, e.RemHead (moduleList));
  165.   WHILE thisModule # NIL DO
  166.     SYS.DISPOSE (thisModule);
  167.     thisModule := SYS.VAL (e.MinNodePtr, e.RemHead (moduleList));
  168.   END;
  169.   currentModule := NIL; currentModuleNo := 0;
  170.  
  171.   file := 0;
  172.   WHILE file < NumFiles DO
  173.     extLength [file] := str.Length (extensions [file]); INC (file)
  174.   END;
  175.  
  176.   IF d.Examine (currentDir, fileInfo^) THEN
  177.     WHILE d.ExNext (currentDir, fileInfo^) DO
  178.       IF fileInfo.dirEntryType < 0 THEN
  179.         file := 0;
  180.         LOOP
  181.           IF file >= NumFiles THEN EXIT; END;
  182.           fileLength := str.Length (fileInfo.fileName);
  183.           dotPos := fileLength - extLength [file] - 1;
  184.           IF (dotPos >= 0) & (fileInfo.fileName [dotPos] = ".") THEN
  185.             str.Extract
  186.               (fileInfo.fileName, dotPos + 1, extLength [file], extension);
  187.             IF str2.CompareCAP (extension, extensions [file]) = 0 THEN
  188.               str.Extract (fileInfo.fileName, 0, dotPos, module);
  189.               IF e.FindName (moduleList, module) = NIL THEN
  190.                 MakeModule (module);
  191.               END;
  192.               EXIT
  193.             END;
  194.           END;
  195.           INC (file)
  196.         END; (* LOOP *)
  197.       END; (* IF *)
  198.     END; (* WHILE *)
  199.   ELSE
  200.     result := FALSE
  201.   END;
  202.  
  203.   SYS.DISPOSE (fileInfo);
  204.   RETURN result;
  205. END ScanModules;
  206.  
  207.  
  208. (*------------------------------------*)
  209. PROCEDURE LoadProgram * ( program : ARRAY OF CHAR ) : BOOLEAN;
  210.  
  211. VAR
  212.   progFile : is.FileDataPtr;
  213.   prgName : Path;
  214.   module : FileName;
  215.   thisModule : e.MinNodePtr;
  216.   fileResult : INTEGER;
  217.   result : BOOLEAN;
  218.  
  219. <*$CopyArrays-*>
  220. BEGIN (* LoadProgram *)
  221.   result := TRUE;
  222.  
  223.   thisModule := SYS.VAL (e.MinNodePtr, e.RemHead (moduleList));
  224.   WHILE thisModule # NIL DO
  225.     SYS.DISPOSE (thisModule);
  226.     thisModule := SYS.VAL (e.MinNodePtr, e.RemHead (moduleList))
  227.   END;
  228.   currentModule := NIL; currentModuleNo := 0;
  229.  
  230.   COPY (program, programName);
  231.   COPY (program, prgName);
  232.   str.Append (".prg", prgName);
  233.  
  234.   progFile :=
  235.     is.OpenTextFile
  236.       ( prgName, 1000, 100, {is.tfTrimLine .. is.tfSkipEmptyLines});
  237.   IF progFile # NIL THEN
  238.     module := "";
  239.     LOOP
  240.       fileResult := is.ReadTextLine (progFile);
  241.       IF fileResult # is.normal THEN EXIT END;
  242.       COPY (progFile.line^, module);
  243.       IF module [0] # 0X THEN MakeModule (module) END
  244.     END;
  245.     is.CloseTextFile (progFile)
  246.   ELSE
  247.     result := FALSE
  248.   END;
  249.  
  250.   RETURN result;
  251. END LoadProgram;
  252.  
  253.  
  254. (*------------------------------------*)
  255. PROCEDURE SaveProgram * () : BOOLEAN;
  256.  
  257. VAR
  258.   progFile : d.FileHandlePtr;
  259.   prgName : Path;
  260.   module : ModuleNodePtr;
  261.   result : BOOLEAN;
  262.  
  263.   PROCEDURE WriteLine ( string : ARRAY OF CHAR );
  264.  
  265.   VAR ch : CHAR;
  266.       fileResult : LONGINT;
  267.  
  268.   <*$CopyArrays-*>
  269.   BEGIN (* WriteLine *)
  270.     fileResult := d.Write (progFile, string, str.Length (string));
  271.     ch := "\n"; fileResult := d.Write (progFile, ch, 1);
  272.   END WriteLine;
  273.  
  274. BEGIN (* SaveProgram *)
  275.   result := TRUE;
  276.   COPY (programName, prgName);
  277.   str.Append (".prg", prgName);
  278.  
  279.   progFile := d.Open (prgName, d.newFile);
  280.   IF progFile # NIL THEN
  281.     module := SYS.VAL (ModuleNodePtr, eu.GetHead (moduleList));
  282.     WHILE module # NIL DO
  283.       WriteLine (module.modName);
  284.       module := SYS.VAL (ModuleNodePtr, eu.GetSucc (module))
  285.     END;
  286.     d.OldClose( progFile );
  287.   ELSE
  288.     result := FALSE;
  289.   END;
  290.  
  291.   RETURN result;
  292. END SaveProgram;
  293.  
  294.  
  295. (*------------------------------------*)
  296. PROCEDURE LoadSetup * ( setupDir, setupFile : ARRAY OF CHAR );
  297.  
  298.   VAR
  299.     setupPath : Path; pf : d.FileHandlePtr; tag : LONGINT;
  300.     i, ver : INTEGER; c : CHAR;
  301.  
  302.   PROCEDURE Read ( fh : d.FileHandlePtr; VAR x : SYS.BYTE );
  303.     VAR i : LONGINT;
  304.   BEGIN (* Read *)
  305.     i := d.FGetC (fh); x := CHR (i)
  306.   END Read;
  307.  
  308.   PROCEDURE ReadBytes
  309.     ( fh : d.FileHandlePtr; VAR x : ARRAY OF SYS.BYTE; n : LONGINT );
  310.     VAR i : LONGINT;
  311.   BEGIN (* ReadBytes *)
  312.     i := d.FRead (fh, x, 1, n)
  313.   END ReadBytes;
  314.  
  315.   PROCEDURE ReadString ( fh : d.FileHandlePtr; VAR x : ARRAY OF CHAR );
  316.     VAR ch : CHAR; i : INTEGER;
  317.   BEGIN (* ReadString *)
  318.     i := 0;
  319.     REPEAT
  320.       Read (fh, ch); x [i] := ch; INC (i)
  321.     UNTIL ch = 0X
  322.   END ReadString;
  323.  
  324.   PROCEDURE ReadBool ( fh : d.FileHandlePtr; VAR x : BOOLEAN );
  325.     VAR i : SHORTINT;
  326.   BEGIN (* ReadBool *)
  327.     Read (fh, i); x := (i # 0)
  328.   END ReadBool;
  329.  
  330. <*$CopyArrays-*>
  331. BEGIN (* LoadSetup *)
  332.   COPY (setupDir, setupPath);
  333.   ASSERT (d.AddPart (setupPath, setupFile, PathChars));
  334.   pf := d.Open (setupPath, d.oldFile);
  335.   IF pf # NIL THEN
  336.     ReadBytes (pf, tag, 4);
  337.     IF tag = FPEPF THEN
  338.       Read (pf, c); ver := ORD (c);
  339.       IF ver >= 1 THEN
  340.         FOR i := 0 TO NumTools-1 DO
  341.           ReadString (pf, tools[i].title);
  342.           ReadString (pf, tools[i].command);
  343.           ReadString (pf, tools[i].arguments);
  344.           ReadBool (pf, tools[i].isActive);
  345.           ReadBool (pf, tools[i].hasConsole);
  346.           ReadString (pf, tools[i].console);
  347.           ReadBytes (pf, tools[i].stack, 4)
  348.         END;
  349.         FOR i := 0 TO NumFiles-1 DO
  350.           ReadString (pf, extensions[i])
  351.         END;
  352.       ELSE
  353.         isu.DoNotice
  354.           ( NIL, SYS.ADR (Notice), "Invalid version # for preferences" )
  355.       END
  356.     ELSE
  357.       isu.DoNotice
  358.         ( NIL, SYS.ADR (Notice), "Not a preferences file" )
  359.     END;
  360.     d.OldClose (pf);
  361.   ELSE
  362.     isu.DoNotice
  363.       ( NIL, SYS.ADR (Notice), "Could not open setup file for load" )
  364.   END;
  365. END LoadSetup;
  366.  
  367.  
  368. (*------------------------------------*)
  369. PROCEDURE LoadDefSetup * (defSetup : BOOLEAN);
  370.  
  371.   VAR
  372.     searchPaths : ARRAY 4 OF e.LSTRPTR; baseName : e.LSTRPTR;
  373.     fileName : FileName; path : Path;
  374.  
  375. BEGIN (* LoadDefSetup *)
  376.   searchPaths [0] := SYS.ADR ("S/");
  377.   searchPaths [1] := SYS.ADR ("FPE:S/");
  378.   searchPaths [2] := SYS.ADR ("S:");
  379.   searchPaths [3] := NIL;
  380.   IF defSetup THEN fileName := "Default.fpe"
  381.   ELSE fileName := "Alternate.fpe"
  382.   END;
  383.   IF du.Search (searchPaths, fileName, path) THEN
  384.     IF defSetup THEN COPY (path, DefSetupPath)
  385.     ELSE COPY (path, AltSetupPath)
  386.     END;
  387.     LoadSetup ("", path);
  388.   ELSE
  389.     LoadSetup ("", fileName);
  390.   END;
  391. END LoadDefSetup;
  392.  
  393.  
  394. (*------------------------------------*)
  395. PROCEDURE SaveSetup * ( setupDir, setupFile : ARRAY OF CHAR );
  396.  
  397.   VAR
  398.     setupPath : Path; pf : d.FileHandlePtr;
  399.     tag : LONGINT; i : INTEGER; ver : CHAR;
  400.  
  401.   PROCEDURE Write ( fh : d.FileHandlePtr; x : SYS.BYTE );
  402.     VAR i : LONGINT;
  403.   BEGIN (* Write *)
  404.     i := d.FPutC (fh, ORD (x))
  405.   END Write;
  406.  
  407.   PROCEDURE WriteBytes
  408.     ( fh : d.FileHandlePtr; VAR x : ARRAY OF SYS.BYTE; n : LONGINT );
  409.     VAR i : LONGINT;
  410.   BEGIN (* WriteBytes *)
  411.     i := d.FWrite (fh, x, 1, n)
  412.   END WriteBytes;
  413.  
  414.   PROCEDURE WriteString ( fh : d.FileHandlePtr; x : ARRAY OF CHAR );
  415.   <*$CopyArrays-*>
  416.   BEGIN (* WriteString *)
  417.     WriteBytes (fh, x, str.Length (x)); Write (fh, 0X)
  418.   END WriteString;
  419.  
  420.   PROCEDURE WriteBool ( fh : d.FileHandlePtr; x : BOOLEAN );
  421.     VAR i : SHORTINT;
  422.   BEGIN (* WriteBool *)
  423.     IF x THEN i := 1 ELSE i := 0 END; Write (fh, i)
  424.   END WriteBool;
  425.  
  426. <*$CopyArrays-*>
  427. BEGIN (* SaveSetup *)
  428.   COPY (setupDir, setupPath);
  429.   ASSERT (d.AddPart (setupPath, setupFile, PathChars));
  430.  
  431.   pf := d.Open (setupPath, d.newFile);
  432.   IF pf # NIL THEN
  433.     tag := FPEPF; WriteBytes (pf, tag, 4);
  434.     Write (pf, CHR (PrefsVersion));
  435.  
  436.     FOR i := 0 TO NumTools-1 DO
  437.       WriteString (pf, tools[i].title);
  438.       WriteString (pf, tools[i].command);
  439.       WriteString (pf, tools[i].arguments);
  440.       WriteBool (pf, tools[i].isActive);
  441.       WriteBool (pf, tools[i].hasConsole);
  442.       WriteString (pf, tools[i].console);
  443.       WriteBytes (pf, tools[i].stack, 4)
  444.     END;
  445.     FOR i := 0 TO NumFiles-1 DO
  446.       WriteString (pf, extensions[i])
  447.     END;
  448.  
  449.     d.OldClose (pf);
  450.   ELSE
  451.     isu.DoNotice
  452.       (NIL, SYS.ADR (Notice), "Could not open setup file for save")
  453.   END
  454. END SaveSetup;
  455.  
  456.  
  457. (*------------------------------------*)
  458. PROCEDURE SaveDefSetup * (defSetup : BOOLEAN);
  459.  
  460. BEGIN (* SaveDefSetup *)
  461.   IF defSetup THEN
  462.     SaveSetup ("", DefSetupPath);
  463.   ELSE
  464.     SaveSetup ("", AltSetupPath)
  465.   END
  466. END SaveDefSetup;
  467.  
  468.  
  469. (*------------------------------------*)
  470. PROCEDURE DoTool * ( which : INTEGER );
  471.  
  472.   CONST
  473.     NoInput   = "Failed to open input for tool";
  474.     NoOutput  = "Failed to open output for tool";
  475.     LoadError = "Error loading tool";
  476.  
  477.   VAR
  478.     tempCommand, tempArgs : Path;
  479.     console : Console;
  480.     result : LONGINT;
  481.  
  482.   PROCEDURE Expand
  483.     ( VAR newString : ARRAY OF CHAR; oldString : ARRAY OF CHAR );
  484.  
  485.     VAR oldIndex, newIndex, file : INTEGER;
  486.  
  487.   <*$CopyArrays-*>
  488.   BEGIN (* Expand *)
  489.     oldIndex := 0;
  490.     newIndex := 0;
  491.     newString [0] := 0X;
  492.     LOOP
  493.       IF
  494.         (newIndex >= (LEN(newString) - 1)) OR (oldString [oldIndex] = 0X)
  495.       THEN
  496.         newString [newIndex] := 0X; EXIT
  497.       END; (* IF *)
  498.       IF oldString [oldIndex] = "!" THEN
  499.         INC( oldIndex );
  500.         CASE oldString [oldIndex] OF
  501.           "D" :
  502.             newString [newIndex] := 0X;
  503.             str.Append (currentPath, newString);
  504.             newIndex := str.Length (newString);
  505.           |
  506.           "F" :
  507.             newString [newIndex] := 0X;
  508.             file := 0;
  509.             WHILE file < NumFiles DO
  510.               IF file IN currentFiles THEN
  511.                 str.Append (currentModule.modName, newString);
  512.                 str.Append (".", newString);
  513.                 str.Append (extensions [file], newString);
  514.                 str.Append (" ", newString);
  515.               END; (* IF *)
  516.               INC (file)
  517.             END; (* WHILE *)
  518.             newIndex := str.Length (newString);
  519.           |
  520.           "M" :
  521.             newString [newIndex] := 0X;
  522.             str.Append (currentModule.modName, newString);
  523.             newIndex := str.Length (newString);
  524.           |
  525.           "P" :
  526.             newString [newIndex] := 0X;
  527.             str.Append (programName, newString);
  528.             newIndex := str.Length (newString);
  529.           |
  530.         ELSE
  531.           newString [newIndex] := oldString [oldIndex];
  532.           INC( newIndex );
  533.         END; (* CASE oldString *)
  534.         INC( oldIndex );
  535.       ELSE
  536.         newString [newIndex] := oldString [oldIndex];
  537.         INC( oldIndex ); INC( newIndex )
  538.       END;
  539.     END; (* LOOP *)
  540.   END Expand;
  541.  
  542.   (*------------------------------------*)
  543.   PROCEDURE DosCall ();
  544.  
  545.     VAR file : d.FileHandlePtr;
  546.  
  547.   BEGIN (* DosCall *)
  548.     IF tools [which].hasConsole THEN
  549.       file := d.Open (console, d.oldFile);
  550.       IF file = NIL THEN
  551.         isu.DoNotice (NIL, SYS.ADR (Notice), "Could not open console");
  552.         RETURN
  553.       END
  554.     ELSE
  555.       file := NIL
  556.     END;
  557.  
  558.     str.Append (" ", tempCommand);
  559.     str.Append (tempArgs, tempCommand);
  560.     IF
  561.       d.SystemTags
  562.         ( tempCommand,
  563.           d.sysInput,     file,
  564.           d.sysOutput,    NIL,
  565.           d.sysAsynch,    d.DOSTRUE,
  566.           d.npStackSize,  tools [which].stack,
  567.           u.done )
  568.       = -1
  569.     THEN
  570.       IF file # NIL THEN d.OldClose (file) END;
  571.       isu.DoNotice (NIL, SYS.ADR (Notice), LoadError)
  572.     END;
  573.   END DosCall;
  574.  
  575. BEGIN (* DoTool *)
  576.   Expand (tempCommand, tools [which].command);
  577.   Expand (tempArgs, tools [which].arguments);
  578.   IF tools [which].hasConsole THEN
  579.     Expand (console, tools [which].console);
  580.   END;
  581.   DosCall ()
  582. END DoTool;
  583.  
  584.  
  585. (*------------------------------------*)
  586. PROCEDURE Init * ();
  587.  
  588. BEGIN (* Init *)
  589.   tools [0].title := "Button0";
  590.   tools [1].title := "Button1";
  591.   tools [2].title := "Button2";
  592.   tools [3].title := "Button3";
  593.   tools [4].title := "Button4";
  594.   tools [5].title := "Button5";
  595.   tools [6].title := "Button6";
  596.   tools [7].title := "Button7";
  597.   tools [8].title := "Button8";
  598.   tools [9].title := "Button9";
  599.   tools [10].title := "Button10";
  600.   tools [11].title := "Button11";
  601.   extensions [0] := "ex0";
  602.   extensions [1] := "ex1";
  603.   extensions [2] := "ex2";
  604.   extensions [3] := "ex3";
  605.  
  606.   es.NewList (moduleList);
  607.   LoadDefSetup (TRUE);
  608. END Init;
  609.  
  610. BEGIN
  611.   DefSetupPath := "FPE:S/Default.fpe"; AltSetupPath := "FPE:S/Alternate.fpe"
  612. END Data.
  613.  
  614. (***************************************************************************
  615.  
  616.   $Log: Data.mod $
  617.   Revision 1.12  1995/05/08  16:41:15  fjc
  618.   - Removed inappropriate SHORT() calls.
  619.  
  620.   Revision 1.11  1995/02/07  20:12:32  fjc
  621.   - Release 1.5 update 1
  622.  
  623.   Revision 1.10  1995/01/26  00:15:33  fjc
  624.   - Release 1.5
  625.  
  626.   Revision 1.9  1994/09/25  18:20:54  fjc
  627.   - Uses new syntax for external code declarations
  628.  
  629.   Revision 1.8  1994/08/08  16:13:09  fjc
  630.   Release 1.4
  631.  
  632.   Revision 1.7  1994/06/21  22:03:49  fjc
  633.   - Added code to conditionally use V37+ dos.library instead
  634.     of arp.library.
  635.  
  636.   Revision 1.6  1994/06/17  17:26:27  fjc
  637.   - Updated for release
  638.  
  639.   Revision 1.5  1994/06/09  13:33:46  fjc
  640.   - Incorporated changes in Amiga interface
  641.  
  642.   Revision 1.4  1994/06/04  23:49:52  fjc
  643.   - Changed to use new Amiga interface
  644.  
  645.   Revision 1.3  1994/05/12  21:26:09  fjc
  646.   - Prepared for release
  647.  
  648.   Revision 1.2  1994/01/24  14:33:33  fjc
  649.   Changed version control header
  650.  
  651.   Revision 1.1  1994/01/15  17:32:38  fjc
  652.   Start of revision control
  653.  
  654. ***************************************************************************)
  655.  
  656.  
  657.